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