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