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