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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 22 */ 23 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/init.h> 27 #include <linux/types.h> 28 #include <linux/jiffies.h> 29 #include <linux/async.h> 30 #include <linux/dmi.h> 31 #include <linux/delay.h> 32 #include <linux/slab.h> 33 #include <linux/suspend.h> 34 #include <asm/unaligned.h> 35 36 #ifdef CONFIG_ACPI_PROCFS_POWER 37 #include <linux/proc_fs.h> 38 #include <linux/seq_file.h> 39 #include <asm/uaccess.h> 40 #endif 41 42 #include <linux/acpi.h> 43 #include <linux/power_supply.h> 44 45 #include "battery.h" 46 47 #define PREFIX "ACPI: " 48 49 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF 50 51 #define ACPI_BATTERY_DEVICE_NAME "Battery" 52 53 /* Battery power unit: 0 means mW, 1 means mA */ 54 #define ACPI_BATTERY_POWER_UNIT_MA 1 55 56 #define ACPI_BATTERY_STATE_DISCHARGING 0x1 57 #define ACPI_BATTERY_STATE_CHARGING 0x2 58 #define ACPI_BATTERY_STATE_CRITICAL 0x4 59 60 #define _COMPONENT ACPI_BATTERY_COMPONENT 61 62 ACPI_MODULE_NAME("battery"); 63 64 MODULE_AUTHOR("Paul Diefenbaugh"); 65 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); 66 MODULE_DESCRIPTION("ACPI Battery Driver"); 67 MODULE_LICENSE("GPL"); 68 69 static async_cookie_t async_cookie; 70 static int battery_bix_broken_package; 71 static int battery_notification_delay_ms; 72 static unsigned int cache_time = 1000; 73 module_param(cache_time, uint, 0644); 74 MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); 75 76 #ifdef CONFIG_ACPI_PROCFS_POWER 77 extern struct proc_dir_entry *acpi_lock_battery_dir(void); 78 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir); 79 80 enum acpi_battery_files { 81 info_tag = 0, 82 state_tag, 83 alarm_tag, 84 ACPI_BATTERY_NUMFILES, 85 }; 86 87 #endif 88 89 static const struct acpi_device_id battery_device_ids[] = { 90 {"PNP0C0A", 0}, 91 {"", 0}, 92 }; 93 94 MODULE_DEVICE_TABLE(acpi, battery_device_ids); 95 96 enum { 97 ACPI_BATTERY_ALARM_PRESENT, 98 ACPI_BATTERY_XINFO_PRESENT, 99 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, 100 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit 101 switches between mWh and mAh depending on whether the system 102 is running on battery or not. When mAh is the unit, most 103 reported values are incorrect and need to be adjusted by 104 10000/design_voltage. Verified on x201, t410, t410s, and x220. 105 Pre-2010 and 2012 models appear to always report in mWh and 106 are thus unaffected (tested with t42, t61, t500, x200, x300, 107 and x230). Also, in mid-2012 Lenovo issued a BIOS update for 108 the 2011 models that fixes the issue (tested on x220 with a 109 post-1.29 BIOS), but as of Nov. 2012, no such update is 110 available for the 2010 models. */ 111 ACPI_BATTERY_QUIRK_THINKPAD_MAH, 112 }; 113 114 struct acpi_battery { 115 struct mutex lock; 116 struct mutex sysfs_lock; 117 struct power_supply *bat; 118 struct power_supply_desc bat_desc; 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) power_supply_get_drvdata(x) 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 /* -------------------------------------------------------------------------- 339 Battery Management 340 -------------------------------------------------------------------------- */ 341 struct acpi_offsets { 342 size_t offset; /* offset inside struct acpi_sbs_battery */ 343 u8 mode; /* int or string? */ 344 }; 345 346 static const struct acpi_offsets state_offsets[] = { 347 {offsetof(struct acpi_battery, state), 0}, 348 {offsetof(struct acpi_battery, rate_now), 0}, 349 {offsetof(struct acpi_battery, capacity_now), 0}, 350 {offsetof(struct acpi_battery, voltage_now), 0}, 351 }; 352 353 static const struct acpi_offsets info_offsets[] = { 354 {offsetof(struct acpi_battery, power_unit), 0}, 355 {offsetof(struct acpi_battery, design_capacity), 0}, 356 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 357 {offsetof(struct acpi_battery, technology), 0}, 358 {offsetof(struct acpi_battery, design_voltage), 0}, 359 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 360 {offsetof(struct acpi_battery, design_capacity_low), 0}, 361 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 362 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 363 {offsetof(struct acpi_battery, model_number), 1}, 364 {offsetof(struct acpi_battery, serial_number), 1}, 365 {offsetof(struct acpi_battery, type), 1}, 366 {offsetof(struct acpi_battery, oem_info), 1}, 367 }; 368 369 static const struct acpi_offsets extended_info_offsets[] = { 370 {offsetof(struct acpi_battery, revision), 0}, 371 {offsetof(struct acpi_battery, power_unit), 0}, 372 {offsetof(struct acpi_battery, design_capacity), 0}, 373 {offsetof(struct acpi_battery, full_charge_capacity), 0}, 374 {offsetof(struct acpi_battery, technology), 0}, 375 {offsetof(struct acpi_battery, design_voltage), 0}, 376 {offsetof(struct acpi_battery, design_capacity_warning), 0}, 377 {offsetof(struct acpi_battery, design_capacity_low), 0}, 378 {offsetof(struct acpi_battery, cycle_count), 0}, 379 {offsetof(struct acpi_battery, measurement_accuracy), 0}, 380 {offsetof(struct acpi_battery, max_sampling_time), 0}, 381 {offsetof(struct acpi_battery, min_sampling_time), 0}, 382 {offsetof(struct acpi_battery, max_averaging_interval), 0}, 383 {offsetof(struct acpi_battery, min_averaging_interval), 0}, 384 {offsetof(struct acpi_battery, capacity_granularity_1), 0}, 385 {offsetof(struct acpi_battery, capacity_granularity_2), 0}, 386 {offsetof(struct acpi_battery, model_number), 1}, 387 {offsetof(struct acpi_battery, serial_number), 1}, 388 {offsetof(struct acpi_battery, type), 1}, 389 {offsetof(struct acpi_battery, oem_info), 1}, 390 }; 391 392 static int extract_package(struct acpi_battery *battery, 393 union acpi_object *package, 394 const struct acpi_offsets *offsets, int num) 395 { 396 int i; 397 union acpi_object *element; 398 if (package->type != ACPI_TYPE_PACKAGE) 399 return -EFAULT; 400 for (i = 0; i < num; ++i) { 401 if (package->package.count <= i) 402 return -EFAULT; 403 element = &package->package.elements[i]; 404 if (offsets[i].mode) { 405 u8 *ptr = (u8 *)battery + offsets[i].offset; 406 if (element->type == ACPI_TYPE_STRING || 407 element->type == ACPI_TYPE_BUFFER) 408 strncpy(ptr, element->string.pointer, 32); 409 else if (element->type == ACPI_TYPE_INTEGER) { 410 strncpy(ptr, (u8 *)&element->integer.value, 411 sizeof(u64)); 412 ptr[sizeof(u64)] = 0; 413 } else 414 *ptr = 0; /* don't have value */ 415 } else { 416 int *x = (int *)((u8 *)battery + offsets[i].offset); 417 *x = (element->type == ACPI_TYPE_INTEGER) ? 418 element->integer.value : -1; 419 } 420 } 421 return 0; 422 } 423 424 static int acpi_battery_get_status(struct acpi_battery *battery) 425 { 426 if (acpi_bus_get_status(battery->device)) { 427 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA")); 428 return -ENODEV; 429 } 430 return 0; 431 } 432 433 static int acpi_battery_get_info(struct acpi_battery *battery) 434 { 435 int result = -EFAULT; 436 acpi_status status = 0; 437 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ? 438 "_BIX" : "_BIF"; 439 440 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 441 442 if (!acpi_battery_present(battery)) 443 return 0; 444 mutex_lock(&battery->lock); 445 status = acpi_evaluate_object(battery->device->handle, name, 446 NULL, &buffer); 447 mutex_unlock(&battery->lock); 448 449 if (ACPI_FAILURE(status)) { 450 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name)); 451 return -ENODEV; 452 } 453 454 if (battery_bix_broken_package) 455 result = extract_package(battery, buffer.pointer, 456 extended_info_offsets + 1, 457 ARRAY_SIZE(extended_info_offsets) - 1); 458 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)) 459 result = extract_package(battery, buffer.pointer, 460 extended_info_offsets, 461 ARRAY_SIZE(extended_info_offsets)); 462 else 463 result = extract_package(battery, buffer.pointer, 464 info_offsets, ARRAY_SIZE(info_offsets)); 465 kfree(buffer.pointer); 466 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 467 battery->full_charge_capacity = battery->design_capacity; 468 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 469 battery->power_unit && battery->design_voltage) { 470 battery->design_capacity = battery->design_capacity * 471 10000 / battery->design_voltage; 472 battery->full_charge_capacity = battery->full_charge_capacity * 473 10000 / battery->design_voltage; 474 battery->design_capacity_warning = 475 battery->design_capacity_warning * 476 10000 / battery->design_voltage; 477 /* Curiously, design_capacity_low, unlike the rest of them, 478 is correct. */ 479 /* capacity_granularity_* equal 1 on the systems tested, so 480 it's impossible to tell if they would need an adjustment 481 or not if their values were higher. */ 482 } 483 return result; 484 } 485 486 static int acpi_battery_get_state(struct acpi_battery *battery) 487 { 488 int result = 0; 489 acpi_status status = 0; 490 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 491 492 if (!acpi_battery_present(battery)) 493 return 0; 494 495 if (battery->update_time && 496 time_before(jiffies, battery->update_time + 497 msecs_to_jiffies(cache_time))) 498 return 0; 499 500 mutex_lock(&battery->lock); 501 status = acpi_evaluate_object(battery->device->handle, "_BST", 502 NULL, &buffer); 503 mutex_unlock(&battery->lock); 504 505 if (ACPI_FAILURE(status)) { 506 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST")); 507 return -ENODEV; 508 } 509 510 result = extract_package(battery, buffer.pointer, 511 state_offsets, ARRAY_SIZE(state_offsets)); 512 battery->update_time = jiffies; 513 kfree(buffer.pointer); 514 515 /* For buggy DSDTs that report negative 16-bit values for either 516 * charging or discharging current and/or report 0 as 65536 517 * due to bad math. 518 */ 519 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA && 520 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN && 521 (s16)(battery->rate_now) < 0) { 522 battery->rate_now = abs((s16)battery->rate_now); 523 printk_once(KERN_WARNING FW_BUG 524 "battery: (dis)charge rate invalid.\n"); 525 } 526 527 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags) 528 && battery->capacity_now >= 0 && battery->capacity_now <= 100) 529 battery->capacity_now = (battery->capacity_now * 530 battery->full_charge_capacity) / 100; 531 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 532 battery->power_unit && battery->design_voltage) { 533 battery->capacity_now = battery->capacity_now * 534 10000 / battery->design_voltage; 535 } 536 return result; 537 } 538 539 static int acpi_battery_set_alarm(struct acpi_battery *battery) 540 { 541 acpi_status status = 0; 542 543 if (!acpi_battery_present(battery) || 544 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) 545 return -ENODEV; 546 547 mutex_lock(&battery->lock); 548 status = acpi_execute_simple_method(battery->device->handle, "_BTP", 549 battery->alarm); 550 mutex_unlock(&battery->lock); 551 552 if (ACPI_FAILURE(status)) 553 return -ENODEV; 554 555 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); 556 return 0; 557 } 558 559 static int acpi_battery_init_alarm(struct acpi_battery *battery) 560 { 561 /* See if alarms are supported, and if so, set default */ 562 if (!acpi_has_method(battery->device->handle, "_BTP")) { 563 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 564 return 0; 565 } 566 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 567 if (!battery->alarm) 568 battery->alarm = battery->design_capacity_warning; 569 return acpi_battery_set_alarm(battery); 570 } 571 572 static ssize_t acpi_battery_alarm_show(struct device *dev, 573 struct device_attribute *attr, 574 char *buf) 575 { 576 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 577 return sprintf(buf, "%d\n", battery->alarm * 1000); 578 } 579 580 static ssize_t acpi_battery_alarm_store(struct device *dev, 581 struct device_attribute *attr, 582 const char *buf, size_t count) 583 { 584 unsigned long x; 585 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 586 if (sscanf(buf, "%lu\n", &x) == 1) 587 battery->alarm = x/1000; 588 if (acpi_battery_present(battery)) 589 acpi_battery_set_alarm(battery); 590 return count; 591 } 592 593 static struct device_attribute alarm_attr = { 594 .attr = {.name = "alarm", .mode = 0644}, 595 .show = acpi_battery_alarm_show, 596 .store = acpi_battery_alarm_store, 597 }; 598 599 static int sysfs_add_battery(struct acpi_battery *battery) 600 { 601 struct power_supply_config psy_cfg = { .drv_data = battery, }; 602 603 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) { 604 battery->bat_desc.properties = charge_battery_props; 605 battery->bat_desc.num_properties = 606 ARRAY_SIZE(charge_battery_props); 607 } else { 608 battery->bat_desc.properties = energy_battery_props; 609 battery->bat_desc.num_properties = 610 ARRAY_SIZE(energy_battery_props); 611 } 612 613 battery->bat_desc.name = acpi_device_bid(battery->device); 614 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY; 615 battery->bat_desc.get_property = acpi_battery_get_property; 616 617 battery->bat = power_supply_register_no_ws(&battery->device->dev, 618 &battery->bat_desc, &psy_cfg); 619 620 if (IS_ERR(battery->bat)) { 621 int result = PTR_ERR(battery->bat); 622 623 battery->bat = NULL; 624 return result; 625 } 626 return device_create_file(&battery->bat->dev, &alarm_attr); 627 } 628 629 static void sysfs_remove_battery(struct acpi_battery *battery) 630 { 631 mutex_lock(&battery->sysfs_lock); 632 if (!battery->bat) { 633 mutex_unlock(&battery->sysfs_lock); 634 return; 635 } 636 637 device_remove_file(&battery->bat->dev, &alarm_attr); 638 power_supply_unregister(battery->bat); 639 battery->bat = NULL; 640 mutex_unlock(&battery->sysfs_lock); 641 } 642 643 static void find_battery(const struct dmi_header *dm, void *private) 644 { 645 struct acpi_battery *battery = (struct acpi_battery *)private; 646 /* Note: the hardcoded offsets below have been extracted from 647 the source code of dmidecode. */ 648 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) { 649 const u8 *dmi_data = (const u8 *)(dm + 1); 650 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6)); 651 if (dm->length >= 18) 652 dmi_capacity *= dmi_data[17]; 653 if (battery->design_capacity * battery->design_voltage / 1000 654 != dmi_capacity && 655 battery->design_capacity * 10 == dmi_capacity) 656 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 657 &battery->flags); 658 } 659 } 660 661 /* 662 * According to the ACPI spec, some kinds of primary batteries can 663 * report percentage battery remaining capacity directly to OS. 664 * In this case, it reports the Last Full Charged Capacity == 100 665 * and BatteryPresentRate == 0xFFFFFFFF. 666 * 667 * Now we found some battery reports percentage remaining capacity 668 * even if it's rechargeable. 669 * https://bugzilla.kernel.org/show_bug.cgi?id=15979 670 * 671 * Handle this correctly so that they won't break userspace. 672 */ 673 static void acpi_battery_quirks(struct acpi_battery *battery) 674 { 675 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 676 return; 677 678 if (battery->full_charge_capacity == 100 && 679 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN && 680 battery->capacity_now >= 0 && battery->capacity_now <= 100) { 681 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags); 682 battery->full_charge_capacity = battery->design_capacity; 683 battery->capacity_now = (battery->capacity_now * 684 battery->full_charge_capacity) / 100; 685 } 686 687 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags)) 688 return; 689 690 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) { 691 const char *s; 692 s = dmi_get_system_info(DMI_PRODUCT_VERSION); 693 if (s && !strncasecmp(s, "ThinkPad", 8)) { 694 dmi_walk(find_battery, battery); 695 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 696 &battery->flags) && 697 battery->design_voltage) { 698 battery->design_capacity = 699 battery->design_capacity * 700 10000 / battery->design_voltage; 701 battery->full_charge_capacity = 702 battery->full_charge_capacity * 703 10000 / battery->design_voltage; 704 battery->design_capacity_warning = 705 battery->design_capacity_warning * 706 10000 / battery->design_voltage; 707 battery->capacity_now = battery->capacity_now * 708 10000 / battery->design_voltage; 709 } 710 } 711 } 712 } 713 714 static int acpi_battery_update(struct acpi_battery *battery, bool resume) 715 { 716 int result, old_present = acpi_battery_present(battery); 717 result = acpi_battery_get_status(battery); 718 if (result) 719 return result; 720 if (!acpi_battery_present(battery)) { 721 sysfs_remove_battery(battery); 722 battery->update_time = 0; 723 return 0; 724 } 725 726 if (resume) 727 return 0; 728 729 if (!battery->update_time || 730 old_present != acpi_battery_present(battery)) { 731 result = acpi_battery_get_info(battery); 732 if (result) 733 return result; 734 acpi_battery_init_alarm(battery); 735 } 736 737 result = acpi_battery_get_state(battery); 738 if (result) 739 return result; 740 acpi_battery_quirks(battery); 741 742 if (!battery->bat) { 743 result = sysfs_add_battery(battery); 744 if (result) 745 return result; 746 } 747 748 /* 749 * Wakeup the system if battery is critical low 750 * or lower than the alarm level 751 */ 752 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) || 753 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) && 754 (battery->capacity_now <= battery->alarm))) 755 pm_wakeup_event(&battery->device->dev, 0); 756 757 return result; 758 } 759 760 static void acpi_battery_refresh(struct acpi_battery *battery) 761 { 762 int power_unit; 763 764 if (!battery->bat) 765 return; 766 767 power_unit = battery->power_unit; 768 769 acpi_battery_get_info(battery); 770 771 if (power_unit == battery->power_unit) 772 return; 773 774 /* The battery has changed its reporting units. */ 775 sysfs_remove_battery(battery); 776 sysfs_add_battery(battery); 777 } 778 779 /* -------------------------------------------------------------------------- 780 FS Interface (/proc) 781 -------------------------------------------------------------------------- */ 782 783 #ifdef CONFIG_ACPI_PROCFS_POWER 784 static struct proc_dir_entry *acpi_battery_dir; 785 786 static const char *acpi_battery_units(const struct acpi_battery *battery) 787 { 788 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ? 789 "mA" : "mW"; 790 } 791 792 static int acpi_battery_print_info(struct seq_file *seq, int result) 793 { 794 struct acpi_battery *battery = seq->private; 795 796 if (result) 797 goto end; 798 799 seq_printf(seq, "present: %s\n", 800 acpi_battery_present(battery) ? "yes" : "no"); 801 if (!acpi_battery_present(battery)) 802 goto end; 803 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 804 seq_printf(seq, "design capacity: unknown\n"); 805 else 806 seq_printf(seq, "design capacity: %d %sh\n", 807 battery->design_capacity, 808 acpi_battery_units(battery)); 809 810 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 811 seq_printf(seq, "last full capacity: unknown\n"); 812 else 813 seq_printf(seq, "last full capacity: %d %sh\n", 814 battery->full_charge_capacity, 815 acpi_battery_units(battery)); 816 817 seq_printf(seq, "battery technology: %srechargeable\n", 818 (!battery->technology)?"non-":""); 819 820 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 821 seq_printf(seq, "design voltage: unknown\n"); 822 else 823 seq_printf(seq, "design voltage: %d mV\n", 824 battery->design_voltage); 825 seq_printf(seq, "design capacity warning: %d %sh\n", 826 battery->design_capacity_warning, 827 acpi_battery_units(battery)); 828 seq_printf(seq, "design capacity low: %d %sh\n", 829 battery->design_capacity_low, 830 acpi_battery_units(battery)); 831 seq_printf(seq, "cycle count: %i\n", battery->cycle_count); 832 seq_printf(seq, "capacity granularity 1: %d %sh\n", 833 battery->capacity_granularity_1, 834 acpi_battery_units(battery)); 835 seq_printf(seq, "capacity granularity 2: %d %sh\n", 836 battery->capacity_granularity_2, 837 acpi_battery_units(battery)); 838 seq_printf(seq, "model number: %s\n", battery->model_number); 839 seq_printf(seq, "serial number: %s\n", battery->serial_number); 840 seq_printf(seq, "battery type: %s\n", battery->type); 841 seq_printf(seq, "OEM info: %s\n", battery->oem_info); 842 end: 843 if (result) 844 seq_printf(seq, "ERROR: Unable to read battery info\n"); 845 return result; 846 } 847 848 static int acpi_battery_print_state(struct seq_file *seq, int result) 849 { 850 struct acpi_battery *battery = seq->private; 851 852 if (result) 853 goto end; 854 855 seq_printf(seq, "present: %s\n", 856 acpi_battery_present(battery) ? "yes" : "no"); 857 if (!acpi_battery_present(battery)) 858 goto end; 859 860 seq_printf(seq, "capacity state: %s\n", 861 (battery->state & 0x04) ? "critical" : "ok"); 862 if ((battery->state & 0x01) && (battery->state & 0x02)) 863 seq_printf(seq, 864 "charging state: charging/discharging\n"); 865 else if (battery->state & 0x01) 866 seq_printf(seq, "charging state: discharging\n"); 867 else if (battery->state & 0x02) 868 seq_printf(seq, "charging state: charging\n"); 869 else 870 seq_printf(seq, "charging state: charged\n"); 871 872 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 873 seq_printf(seq, "present rate: unknown\n"); 874 else 875 seq_printf(seq, "present rate: %d %s\n", 876 battery->rate_now, acpi_battery_units(battery)); 877 878 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 879 seq_printf(seq, "remaining capacity: unknown\n"); 880 else 881 seq_printf(seq, "remaining capacity: %d %sh\n", 882 battery->capacity_now, acpi_battery_units(battery)); 883 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 884 seq_printf(seq, "present voltage: unknown\n"); 885 else 886 seq_printf(seq, "present voltage: %d mV\n", 887 battery->voltage_now); 888 end: 889 if (result) 890 seq_printf(seq, "ERROR: Unable to read battery state\n"); 891 892 return result; 893 } 894 895 static int acpi_battery_print_alarm(struct seq_file *seq, int result) 896 { 897 struct acpi_battery *battery = seq->private; 898 899 if (result) 900 goto end; 901 902 if (!acpi_battery_present(battery)) { 903 seq_printf(seq, "present: no\n"); 904 goto end; 905 } 906 seq_printf(seq, "alarm: "); 907 if (!battery->alarm) 908 seq_printf(seq, "unsupported\n"); 909 else 910 seq_printf(seq, "%u %sh\n", battery->alarm, 911 acpi_battery_units(battery)); 912 end: 913 if (result) 914 seq_printf(seq, "ERROR: Unable to read battery alarm\n"); 915 return result; 916 } 917 918 static ssize_t acpi_battery_write_alarm(struct file *file, 919 const char __user * buffer, 920 size_t count, loff_t * ppos) 921 { 922 int result = 0; 923 char alarm_string[12] = { '\0' }; 924 struct seq_file *m = file->private_data; 925 struct acpi_battery *battery = m->private; 926 927 if (!battery || (count > sizeof(alarm_string) - 1)) 928 return -EINVAL; 929 if (!acpi_battery_present(battery)) { 930 result = -ENODEV; 931 goto end; 932 } 933 if (copy_from_user(alarm_string, buffer, count)) { 934 result = -EFAULT; 935 goto end; 936 } 937 alarm_string[count] = '\0'; 938 if (kstrtoint(alarm_string, 0, &battery->alarm)) { 939 result = -EINVAL; 940 goto end; 941 } 942 result = acpi_battery_set_alarm(battery); 943 end: 944 if (!result) 945 return count; 946 return result; 947 } 948 949 typedef int(*print_func)(struct seq_file *seq, int result); 950 951 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = { 952 acpi_battery_print_info, 953 acpi_battery_print_state, 954 acpi_battery_print_alarm, 955 }; 956 957 static int acpi_battery_read(int fid, struct seq_file *seq) 958 { 959 struct acpi_battery *battery = seq->private; 960 int result = acpi_battery_update(battery, false); 961 return acpi_print_funcs[fid](seq, result); 962 } 963 964 #define DECLARE_FILE_FUNCTIONS(_name) \ 965 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \ 966 { \ 967 return acpi_battery_read(_name##_tag, seq); \ 968 } \ 969 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \ 970 { \ 971 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \ 972 } 973 974 DECLARE_FILE_FUNCTIONS(info); 975 DECLARE_FILE_FUNCTIONS(state); 976 DECLARE_FILE_FUNCTIONS(alarm); 977 978 #undef DECLARE_FILE_FUNCTIONS 979 980 #define FILE_DESCRIPTION_RO(_name) \ 981 { \ 982 .name = __stringify(_name), \ 983 .mode = S_IRUGO, \ 984 .ops = { \ 985 .open = acpi_battery_##_name##_open_fs, \ 986 .read = seq_read, \ 987 .llseek = seq_lseek, \ 988 .release = single_release, \ 989 .owner = THIS_MODULE, \ 990 }, \ 991 } 992 993 #define FILE_DESCRIPTION_RW(_name) \ 994 { \ 995 .name = __stringify(_name), \ 996 .mode = S_IFREG | S_IRUGO | S_IWUSR, \ 997 .ops = { \ 998 .open = acpi_battery_##_name##_open_fs, \ 999 .read = seq_read, \ 1000 .llseek = seq_lseek, \ 1001 .write = acpi_battery_write_##_name, \ 1002 .release = single_release, \ 1003 .owner = THIS_MODULE, \ 1004 }, \ 1005 } 1006 1007 static const struct battery_file { 1008 struct file_operations ops; 1009 umode_t mode; 1010 const char *name; 1011 } acpi_battery_file[] = { 1012 FILE_DESCRIPTION_RO(info), 1013 FILE_DESCRIPTION_RO(state), 1014 FILE_DESCRIPTION_RW(alarm), 1015 }; 1016 1017 #undef FILE_DESCRIPTION_RO 1018 #undef FILE_DESCRIPTION_RW 1019 1020 static int acpi_battery_add_fs(struct acpi_device *device) 1021 { 1022 struct proc_dir_entry *entry = NULL; 1023 int i; 1024 1025 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded," 1026 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n"); 1027 if (!acpi_device_dir(device)) { 1028 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 1029 acpi_battery_dir); 1030 if (!acpi_device_dir(device)) 1031 return -ENODEV; 1032 } 1033 1034 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) { 1035 entry = proc_create_data(acpi_battery_file[i].name, 1036 acpi_battery_file[i].mode, 1037 acpi_device_dir(device), 1038 &acpi_battery_file[i].ops, 1039 acpi_driver_data(device)); 1040 if (!entry) 1041 return -ENODEV; 1042 } 1043 return 0; 1044 } 1045 1046 static void acpi_battery_remove_fs(struct acpi_device *device) 1047 { 1048 int i; 1049 if (!acpi_device_dir(device)) 1050 return; 1051 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) 1052 remove_proc_entry(acpi_battery_file[i].name, 1053 acpi_device_dir(device)); 1054 1055 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir); 1056 acpi_device_dir(device) = NULL; 1057 } 1058 1059 #endif 1060 1061 /* -------------------------------------------------------------------------- 1062 Driver Interface 1063 -------------------------------------------------------------------------- */ 1064 1065 static void acpi_battery_notify(struct acpi_device *device, u32 event) 1066 { 1067 struct acpi_battery *battery = acpi_driver_data(device); 1068 struct power_supply *old; 1069 1070 if (!battery) 1071 return; 1072 old = battery->bat; 1073 /* 1074 * On Acer Aspire V5-573G notifications are sometimes triggered too 1075 * early. For example, when AC is unplugged and notification is 1076 * triggered, battery state is still reported as "Full", and changes to 1077 * "Discharging" only after short delay, without any notification. 1078 */ 1079 if (battery_notification_delay_ms > 0) 1080 msleep(battery_notification_delay_ms); 1081 if (event == ACPI_BATTERY_NOTIFY_INFO) 1082 acpi_battery_refresh(battery); 1083 acpi_battery_update(battery, false); 1084 acpi_bus_generate_netlink_event(device->pnp.device_class, 1085 dev_name(&device->dev), event, 1086 acpi_battery_present(battery)); 1087 acpi_notifier_call_chain(device, event, acpi_battery_present(battery)); 1088 /* acpi_battery_update could remove power_supply object */ 1089 if (old && battery->bat) 1090 power_supply_changed(battery->bat); 1091 } 1092 1093 static int battery_notify(struct notifier_block *nb, 1094 unsigned long mode, void *_unused) 1095 { 1096 struct acpi_battery *battery = container_of(nb, struct acpi_battery, 1097 pm_nb); 1098 int result; 1099 1100 switch (mode) { 1101 case PM_POST_HIBERNATION: 1102 case PM_POST_SUSPEND: 1103 if (!acpi_battery_present(battery)) 1104 return 0; 1105 1106 if (!battery->bat) { 1107 result = acpi_battery_get_info(battery); 1108 if (result) 1109 return result; 1110 1111 result = sysfs_add_battery(battery); 1112 if (result) 1113 return result; 1114 } else 1115 acpi_battery_refresh(battery); 1116 1117 acpi_battery_init_alarm(battery); 1118 acpi_battery_get_state(battery); 1119 break; 1120 } 1121 1122 return 0; 1123 } 1124 1125 static int __init 1126 battery_bix_broken_package_quirk(const struct dmi_system_id *d) 1127 { 1128 battery_bix_broken_package = 1; 1129 return 0; 1130 } 1131 1132 static int __init 1133 battery_notification_delay_quirk(const struct dmi_system_id *d) 1134 { 1135 battery_notification_delay_ms = 1000; 1136 return 0; 1137 } 1138 1139 static const struct dmi_system_id bat_dmi_table[] __initconst = { 1140 { 1141 .callback = battery_bix_broken_package_quirk, 1142 .ident = "NEC LZ750/LS", 1143 .matches = { 1144 DMI_MATCH(DMI_SYS_VENDOR, "NEC"), 1145 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"), 1146 }, 1147 }, 1148 { 1149 .callback = battery_notification_delay_quirk, 1150 .ident = "Acer Aspire V5-573G", 1151 .matches = { 1152 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 1153 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"), 1154 }, 1155 }, 1156 {}, 1157 }; 1158 1159 /* 1160 * Some machines'(E,G Lenovo Z480) ECs are not stable 1161 * during boot up and this causes battery driver fails to be 1162 * probed due to failure of getting battery information 1163 * from EC sometimes. After several retries, the operation 1164 * may work. So add retry code here and 20ms sleep between 1165 * every retries. 1166 */ 1167 static int acpi_battery_update_retry(struct acpi_battery *battery) 1168 { 1169 int retry, ret; 1170 1171 for (retry = 5; retry; retry--) { 1172 ret = acpi_battery_update(battery, false); 1173 if (!ret) 1174 break; 1175 1176 msleep(20); 1177 } 1178 return ret; 1179 } 1180 1181 static int acpi_battery_add(struct acpi_device *device) 1182 { 1183 int result = 0; 1184 struct acpi_battery *battery = NULL; 1185 1186 if (!device) 1187 return -EINVAL; 1188 1189 if (device->dep_unmet) 1190 return -EPROBE_DEFER; 1191 1192 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); 1193 if (!battery) 1194 return -ENOMEM; 1195 battery->device = device; 1196 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); 1197 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); 1198 device->driver_data = battery; 1199 mutex_init(&battery->lock); 1200 mutex_init(&battery->sysfs_lock); 1201 if (acpi_has_method(battery->device->handle, "_BIX")) 1202 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); 1203 1204 result = acpi_battery_update_retry(battery); 1205 if (result) 1206 goto fail; 1207 1208 #ifdef CONFIG_ACPI_PROCFS_POWER 1209 result = acpi_battery_add_fs(device); 1210 #endif 1211 if (result) { 1212 #ifdef CONFIG_ACPI_PROCFS_POWER 1213 acpi_battery_remove_fs(device); 1214 #endif 1215 goto fail; 1216 } 1217 1218 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", 1219 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), 1220 device->status.battery_present ? "present" : "absent"); 1221 1222 battery->pm_nb.notifier_call = battery_notify; 1223 register_pm_notifier(&battery->pm_nb); 1224 1225 device_init_wakeup(&device->dev, 1); 1226 1227 return result; 1228 1229 fail: 1230 sysfs_remove_battery(battery); 1231 mutex_destroy(&battery->lock); 1232 mutex_destroy(&battery->sysfs_lock); 1233 kfree(battery); 1234 return result; 1235 } 1236 1237 static int acpi_battery_remove(struct acpi_device *device) 1238 { 1239 struct acpi_battery *battery = NULL; 1240 1241 if (!device || !acpi_driver_data(device)) 1242 return -EINVAL; 1243 device_init_wakeup(&device->dev, 0); 1244 battery = acpi_driver_data(device); 1245 unregister_pm_notifier(&battery->pm_nb); 1246 #ifdef CONFIG_ACPI_PROCFS_POWER 1247 acpi_battery_remove_fs(device); 1248 #endif 1249 sysfs_remove_battery(battery); 1250 mutex_destroy(&battery->lock); 1251 mutex_destroy(&battery->sysfs_lock); 1252 kfree(battery); 1253 return 0; 1254 } 1255 1256 #ifdef CONFIG_PM_SLEEP 1257 /* this is needed to learn about changes made in suspended state */ 1258 static int acpi_battery_resume(struct device *dev) 1259 { 1260 struct acpi_battery *battery; 1261 1262 if (!dev) 1263 return -EINVAL; 1264 1265 battery = acpi_driver_data(to_acpi_device(dev)); 1266 if (!battery) 1267 return -EINVAL; 1268 1269 battery->update_time = 0; 1270 acpi_battery_update(battery, true); 1271 return 0; 1272 } 1273 #else 1274 #define acpi_battery_resume NULL 1275 #endif 1276 1277 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume); 1278 1279 static struct acpi_driver acpi_battery_driver = { 1280 .name = "battery", 1281 .class = ACPI_BATTERY_CLASS, 1282 .ids = battery_device_ids, 1283 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 1284 .ops = { 1285 .add = acpi_battery_add, 1286 .remove = acpi_battery_remove, 1287 .notify = acpi_battery_notify, 1288 }, 1289 .drv.pm = &acpi_battery_pm, 1290 }; 1291 1292 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) 1293 { 1294 int result; 1295 1296 dmi_check_system(bat_dmi_table); 1297 1298 #ifdef CONFIG_ACPI_PROCFS_POWER 1299 acpi_battery_dir = acpi_lock_battery_dir(); 1300 if (!acpi_battery_dir) 1301 return; 1302 #endif 1303 result = acpi_bus_register_driver(&acpi_battery_driver); 1304 #ifdef CONFIG_ACPI_PROCFS_POWER 1305 if (result < 0) 1306 acpi_unlock_battery_dir(acpi_battery_dir); 1307 #endif 1308 } 1309 1310 static int __init acpi_battery_init(void) 1311 { 1312 if (acpi_disabled) 1313 return -ENODEV; 1314 1315 async_cookie = async_schedule(acpi_battery_init_async, NULL); 1316 return 0; 1317 } 1318 1319 static void __exit acpi_battery_exit(void) 1320 { 1321 async_synchronize_cookie(async_cookie + 1); 1322 acpi_bus_unregister_driver(&acpi_battery_driver); 1323 #ifdef CONFIG_ACPI_PROCFS_POWER 1324 acpi_unlock_battery_dir(acpi_battery_dir); 1325 #endif 1326 } 1327 1328 module_init(acpi_battery_init); 1329 module_exit(acpi_battery_exit); 1330