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 /* 538 * When fully charged, some batteries wrongly report 539 * capacity_now = design_capacity instead of = full_charge_capacity 540 */ 541 if (battery->capacity_now > battery->full_charge_capacity 542 && battery->full_charge_capacity != ACPI_BATTERY_VALUE_UNKNOWN) { 543 if (battery->capacity_now != battery->design_capacity) 544 printk_once(KERN_WARNING FW_BUG 545 "battery: reported current charge level (%d) " 546 "is higher than reported maximum charge level (%d).\n", 547 battery->capacity_now, battery->full_charge_capacity); 548 battery->capacity_now = battery->full_charge_capacity; 549 } 550 551 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags) 552 && battery->capacity_now >= 0 && battery->capacity_now <= 100) 553 battery->capacity_now = (battery->capacity_now * 554 battery->full_charge_capacity) / 100; 555 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) && 556 battery->power_unit && battery->design_voltage) { 557 battery->capacity_now = battery->capacity_now * 558 10000 / battery->design_voltage; 559 } 560 return result; 561 } 562 563 static int acpi_battery_set_alarm(struct acpi_battery *battery) 564 { 565 acpi_status status = 0; 566 567 if (!acpi_battery_present(battery) || 568 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags)) 569 return -ENODEV; 570 571 mutex_lock(&battery->lock); 572 status = acpi_execute_simple_method(battery->device->handle, "_BTP", 573 battery->alarm); 574 mutex_unlock(&battery->lock); 575 576 if (ACPI_FAILURE(status)) 577 return -ENODEV; 578 579 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm)); 580 return 0; 581 } 582 583 static int acpi_battery_init_alarm(struct acpi_battery *battery) 584 { 585 /* See if alarms are supported, and if so, set default */ 586 if (!acpi_has_method(battery->device->handle, "_BTP")) { 587 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 588 return 0; 589 } 590 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags); 591 if (!battery->alarm) 592 battery->alarm = battery->design_capacity_warning; 593 return acpi_battery_set_alarm(battery); 594 } 595 596 static ssize_t acpi_battery_alarm_show(struct device *dev, 597 struct device_attribute *attr, 598 char *buf) 599 { 600 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 601 return sprintf(buf, "%d\n", battery->alarm * 1000); 602 } 603 604 static ssize_t acpi_battery_alarm_store(struct device *dev, 605 struct device_attribute *attr, 606 const char *buf, size_t count) 607 { 608 unsigned long x; 609 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev)); 610 if (sscanf(buf, "%lu\n", &x) == 1) 611 battery->alarm = x/1000; 612 if (acpi_battery_present(battery)) 613 acpi_battery_set_alarm(battery); 614 return count; 615 } 616 617 static struct device_attribute alarm_attr = { 618 .attr = {.name = "alarm", .mode = 0644}, 619 .show = acpi_battery_alarm_show, 620 .store = acpi_battery_alarm_store, 621 }; 622 623 static int sysfs_add_battery(struct acpi_battery *battery) 624 { 625 int result; 626 627 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) { 628 battery->bat.properties = charge_battery_props; 629 battery->bat.num_properties = 630 ARRAY_SIZE(charge_battery_props); 631 } else { 632 battery->bat.properties = energy_battery_props; 633 battery->bat.num_properties = 634 ARRAY_SIZE(energy_battery_props); 635 } 636 637 battery->bat.name = acpi_device_bid(battery->device); 638 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY; 639 battery->bat.get_property = acpi_battery_get_property; 640 641 result = power_supply_register_no_ws(&battery->device->dev, &battery->bat); 642 643 if (result) 644 return result; 645 return device_create_file(battery->bat.dev, &alarm_attr); 646 } 647 648 static void sysfs_remove_battery(struct acpi_battery *battery) 649 { 650 mutex_lock(&battery->sysfs_lock); 651 if (!battery->bat.dev) { 652 mutex_unlock(&battery->sysfs_lock); 653 return; 654 } 655 656 device_remove_file(battery->bat.dev, &alarm_attr); 657 power_supply_unregister(&battery->bat); 658 battery->bat.dev = NULL; 659 mutex_unlock(&battery->sysfs_lock); 660 } 661 662 static void find_battery(const struct dmi_header *dm, void *private) 663 { 664 struct acpi_battery *battery = (struct acpi_battery *)private; 665 /* Note: the hardcoded offsets below have been extracted from 666 the source code of dmidecode. */ 667 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) { 668 const u8 *dmi_data = (const u8 *)(dm + 1); 669 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6)); 670 if (dm->length >= 18) 671 dmi_capacity *= dmi_data[17]; 672 if (battery->design_capacity * battery->design_voltage / 1000 673 != dmi_capacity && 674 battery->design_capacity * 10 == dmi_capacity) 675 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 676 &battery->flags); 677 } 678 } 679 680 /* 681 * According to the ACPI spec, some kinds of primary batteries can 682 * report percentage battery remaining capacity directly to OS. 683 * In this case, it reports the Last Full Charged Capacity == 100 684 * and BatteryPresentRate == 0xFFFFFFFF. 685 * 686 * Now we found some battery reports percentage remaining capacity 687 * even if it's rechargeable. 688 * https://bugzilla.kernel.org/show_bug.cgi?id=15979 689 * 690 * Handle this correctly so that they won't break userspace. 691 */ 692 static void acpi_battery_quirks(struct acpi_battery *battery) 693 { 694 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)) 695 return; 696 697 if (battery->full_charge_capacity == 100 && 698 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN && 699 battery->capacity_now >= 0 && battery->capacity_now <= 100) { 700 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags); 701 battery->full_charge_capacity = battery->design_capacity; 702 battery->capacity_now = (battery->capacity_now * 703 battery->full_charge_capacity) / 100; 704 } 705 706 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags)) 707 return; 708 709 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) { 710 const char *s; 711 s = dmi_get_system_info(DMI_PRODUCT_VERSION); 712 if (s && !strnicmp(s, "ThinkPad", 8)) { 713 dmi_walk(find_battery, battery); 714 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, 715 &battery->flags) && 716 battery->design_voltage) { 717 battery->design_capacity = 718 battery->design_capacity * 719 10000 / battery->design_voltage; 720 battery->full_charge_capacity = 721 battery->full_charge_capacity * 722 10000 / battery->design_voltage; 723 battery->design_capacity_warning = 724 battery->design_capacity_warning * 725 10000 / battery->design_voltage; 726 battery->capacity_now = battery->capacity_now * 727 10000 / battery->design_voltage; 728 } 729 } 730 } 731 } 732 733 static int acpi_battery_update(struct acpi_battery *battery, bool resume) 734 { 735 int result, old_present = acpi_battery_present(battery); 736 result = acpi_battery_get_status(battery); 737 if (result) 738 return result; 739 if (!acpi_battery_present(battery)) { 740 sysfs_remove_battery(battery); 741 battery->update_time = 0; 742 return 0; 743 } 744 745 if (resume) 746 return 0; 747 748 if (!battery->update_time || 749 old_present != acpi_battery_present(battery)) { 750 result = acpi_battery_get_info(battery); 751 if (result) 752 return result; 753 acpi_battery_init_alarm(battery); 754 } 755 if (!battery->bat.dev) { 756 result = sysfs_add_battery(battery); 757 if (result) 758 return result; 759 } 760 result = acpi_battery_get_state(battery); 761 if (result) 762 return result; 763 acpi_battery_quirks(battery); 764 765 /* 766 * Wakeup the system if battery is critical low 767 * or lower than the alarm level 768 */ 769 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) || 770 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) && 771 (battery->capacity_now <= battery->alarm))) 772 pm_wakeup_event(&battery->device->dev, 0); 773 774 return result; 775 } 776 777 static void acpi_battery_refresh(struct acpi_battery *battery) 778 { 779 int power_unit; 780 781 if (!battery->bat.dev) 782 return; 783 784 power_unit = battery->power_unit; 785 786 acpi_battery_get_info(battery); 787 788 if (power_unit == battery->power_unit) 789 return; 790 791 /* The battery has changed its reporting units. */ 792 sysfs_remove_battery(battery); 793 sysfs_add_battery(battery); 794 } 795 796 /* -------------------------------------------------------------------------- 797 FS Interface (/proc) 798 -------------------------------------------------------------------------- */ 799 800 #ifdef CONFIG_ACPI_PROCFS_POWER 801 static struct proc_dir_entry *acpi_battery_dir; 802 803 static int acpi_battery_print_info(struct seq_file *seq, int result) 804 { 805 struct acpi_battery *battery = seq->private; 806 807 if (result) 808 goto end; 809 810 seq_printf(seq, "present: %s\n", 811 acpi_battery_present(battery) ? "yes" : "no"); 812 if (!acpi_battery_present(battery)) 813 goto end; 814 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 815 seq_printf(seq, "design capacity: unknown\n"); 816 else 817 seq_printf(seq, "design capacity: %d %sh\n", 818 battery->design_capacity, 819 acpi_battery_units(battery)); 820 821 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN) 822 seq_printf(seq, "last full capacity: unknown\n"); 823 else 824 seq_printf(seq, "last full capacity: %d %sh\n", 825 battery->full_charge_capacity, 826 acpi_battery_units(battery)); 827 828 seq_printf(seq, "battery technology: %srechargeable\n", 829 (!battery->technology)?"non-":""); 830 831 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN) 832 seq_printf(seq, "design voltage: unknown\n"); 833 else 834 seq_printf(seq, "design voltage: %d mV\n", 835 battery->design_voltage); 836 seq_printf(seq, "design capacity warning: %d %sh\n", 837 battery->design_capacity_warning, 838 acpi_battery_units(battery)); 839 seq_printf(seq, "design capacity low: %d %sh\n", 840 battery->design_capacity_low, 841 acpi_battery_units(battery)); 842 seq_printf(seq, "cycle count: %i\n", battery->cycle_count); 843 seq_printf(seq, "capacity granularity 1: %d %sh\n", 844 battery->capacity_granularity_1, 845 acpi_battery_units(battery)); 846 seq_printf(seq, "capacity granularity 2: %d %sh\n", 847 battery->capacity_granularity_2, 848 acpi_battery_units(battery)); 849 seq_printf(seq, "model number: %s\n", battery->model_number); 850 seq_printf(seq, "serial number: %s\n", battery->serial_number); 851 seq_printf(seq, "battery type: %s\n", battery->type); 852 seq_printf(seq, "OEM info: %s\n", battery->oem_info); 853 end: 854 if (result) 855 seq_printf(seq, "ERROR: Unable to read battery info\n"); 856 return result; 857 } 858 859 static int acpi_battery_print_state(struct seq_file *seq, int result) 860 { 861 struct acpi_battery *battery = seq->private; 862 863 if (result) 864 goto end; 865 866 seq_printf(seq, "present: %s\n", 867 acpi_battery_present(battery) ? "yes" : "no"); 868 if (!acpi_battery_present(battery)) 869 goto end; 870 871 seq_printf(seq, "capacity state: %s\n", 872 (battery->state & 0x04) ? "critical" : "ok"); 873 if ((battery->state & 0x01) && (battery->state & 0x02)) 874 seq_printf(seq, 875 "charging state: charging/discharging\n"); 876 else if (battery->state & 0x01) 877 seq_printf(seq, "charging state: discharging\n"); 878 else if (battery->state & 0x02) 879 seq_printf(seq, "charging state: charging\n"); 880 else 881 seq_printf(seq, "charging state: charged\n"); 882 883 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN) 884 seq_printf(seq, "present rate: unknown\n"); 885 else 886 seq_printf(seq, "present rate: %d %s\n", 887 battery->rate_now, acpi_battery_units(battery)); 888 889 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN) 890 seq_printf(seq, "remaining capacity: unknown\n"); 891 else 892 seq_printf(seq, "remaining capacity: %d %sh\n", 893 battery->capacity_now, acpi_battery_units(battery)); 894 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN) 895 seq_printf(seq, "present voltage: unknown\n"); 896 else 897 seq_printf(seq, "present voltage: %d mV\n", 898 battery->voltage_now); 899 end: 900 if (result) 901 seq_printf(seq, "ERROR: Unable to read battery state\n"); 902 903 return result; 904 } 905 906 static int acpi_battery_print_alarm(struct seq_file *seq, int result) 907 { 908 struct acpi_battery *battery = seq->private; 909 910 if (result) 911 goto end; 912 913 if (!acpi_battery_present(battery)) { 914 seq_printf(seq, "present: no\n"); 915 goto end; 916 } 917 seq_printf(seq, "alarm: "); 918 if (!battery->alarm) 919 seq_printf(seq, "unsupported\n"); 920 else 921 seq_printf(seq, "%u %sh\n", battery->alarm, 922 acpi_battery_units(battery)); 923 end: 924 if (result) 925 seq_printf(seq, "ERROR: Unable to read battery alarm\n"); 926 return result; 927 } 928 929 static ssize_t acpi_battery_write_alarm(struct file *file, 930 const char __user * buffer, 931 size_t count, loff_t * ppos) 932 { 933 int result = 0; 934 char alarm_string[12] = { '\0' }; 935 struct seq_file *m = file->private_data; 936 struct acpi_battery *battery = m->private; 937 938 if (!battery || (count > sizeof(alarm_string) - 1)) 939 return -EINVAL; 940 if (!acpi_battery_present(battery)) { 941 result = -ENODEV; 942 goto end; 943 } 944 if (copy_from_user(alarm_string, buffer, count)) { 945 result = -EFAULT; 946 goto end; 947 } 948 alarm_string[count] = '\0'; 949 if (kstrtoint(alarm_string, 0, &battery->alarm)) { 950 result = -EINVAL; 951 goto end; 952 } 953 result = acpi_battery_set_alarm(battery); 954 end: 955 if (!result) 956 return count; 957 return result; 958 } 959 960 typedef int(*print_func)(struct seq_file *seq, int result); 961 962 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = { 963 acpi_battery_print_info, 964 acpi_battery_print_state, 965 acpi_battery_print_alarm, 966 }; 967 968 static int acpi_battery_read(int fid, struct seq_file *seq) 969 { 970 struct acpi_battery *battery = seq->private; 971 int result = acpi_battery_update(battery, false); 972 return acpi_print_funcs[fid](seq, result); 973 } 974 975 #define DECLARE_FILE_FUNCTIONS(_name) \ 976 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \ 977 { \ 978 return acpi_battery_read(_name##_tag, seq); \ 979 } \ 980 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \ 981 { \ 982 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \ 983 } 984 985 DECLARE_FILE_FUNCTIONS(info); 986 DECLARE_FILE_FUNCTIONS(state); 987 DECLARE_FILE_FUNCTIONS(alarm); 988 989 #undef DECLARE_FILE_FUNCTIONS 990 991 #define FILE_DESCRIPTION_RO(_name) \ 992 { \ 993 .name = __stringify(_name), \ 994 .mode = S_IRUGO, \ 995 .ops = { \ 996 .open = acpi_battery_##_name##_open_fs, \ 997 .read = seq_read, \ 998 .llseek = seq_lseek, \ 999 .release = single_release, \ 1000 .owner = THIS_MODULE, \ 1001 }, \ 1002 } 1003 1004 #define FILE_DESCRIPTION_RW(_name) \ 1005 { \ 1006 .name = __stringify(_name), \ 1007 .mode = S_IFREG | S_IRUGO | S_IWUSR, \ 1008 .ops = { \ 1009 .open = acpi_battery_##_name##_open_fs, \ 1010 .read = seq_read, \ 1011 .llseek = seq_lseek, \ 1012 .write = acpi_battery_write_##_name, \ 1013 .release = single_release, \ 1014 .owner = THIS_MODULE, \ 1015 }, \ 1016 } 1017 1018 static const struct battery_file { 1019 struct file_operations ops; 1020 umode_t mode; 1021 const char *name; 1022 } acpi_battery_file[] = { 1023 FILE_DESCRIPTION_RO(info), 1024 FILE_DESCRIPTION_RO(state), 1025 FILE_DESCRIPTION_RW(alarm), 1026 }; 1027 1028 #undef FILE_DESCRIPTION_RO 1029 #undef FILE_DESCRIPTION_RW 1030 1031 static int acpi_battery_add_fs(struct acpi_device *device) 1032 { 1033 struct proc_dir_entry *entry = NULL; 1034 int i; 1035 1036 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded," 1037 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n"); 1038 if (!acpi_device_dir(device)) { 1039 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 1040 acpi_battery_dir); 1041 if (!acpi_device_dir(device)) 1042 return -ENODEV; 1043 } 1044 1045 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) { 1046 entry = proc_create_data(acpi_battery_file[i].name, 1047 acpi_battery_file[i].mode, 1048 acpi_device_dir(device), 1049 &acpi_battery_file[i].ops, 1050 acpi_driver_data(device)); 1051 if (!entry) 1052 return -ENODEV; 1053 } 1054 return 0; 1055 } 1056 1057 static void acpi_battery_remove_fs(struct acpi_device *device) 1058 { 1059 int i; 1060 if (!acpi_device_dir(device)) 1061 return; 1062 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) 1063 remove_proc_entry(acpi_battery_file[i].name, 1064 acpi_device_dir(device)); 1065 1066 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir); 1067 acpi_device_dir(device) = NULL; 1068 } 1069 1070 #endif 1071 1072 /* -------------------------------------------------------------------------- 1073 Driver Interface 1074 -------------------------------------------------------------------------- */ 1075 1076 static void acpi_battery_notify(struct acpi_device *device, u32 event) 1077 { 1078 struct acpi_battery *battery = acpi_driver_data(device); 1079 struct device *old; 1080 1081 if (!battery) 1082 return; 1083 old = battery->bat.dev; 1084 /* 1085 * On Acer Aspire V5-573G notifications are sometimes triggered too 1086 * early. For example, when AC is unplugged and notification is 1087 * triggered, battery state is still reported as "Full", and changes to 1088 * "Discharging" only after short delay, without any notification. 1089 */ 1090 if (battery_notification_delay_ms > 0) 1091 msleep(battery_notification_delay_ms); 1092 if (event == ACPI_BATTERY_NOTIFY_INFO) 1093 acpi_battery_refresh(battery); 1094 acpi_battery_update(battery, false); 1095 acpi_bus_generate_netlink_event(device->pnp.device_class, 1096 dev_name(&device->dev), event, 1097 acpi_battery_present(battery)); 1098 acpi_notifier_call_chain(device, event, acpi_battery_present(battery)); 1099 /* acpi_battery_update could remove power_supply object */ 1100 if (old && battery->bat.dev) 1101 power_supply_changed(&battery->bat); 1102 } 1103 1104 static int battery_notify(struct notifier_block *nb, 1105 unsigned long mode, void *_unused) 1106 { 1107 struct acpi_battery *battery = container_of(nb, struct acpi_battery, 1108 pm_nb); 1109 int result; 1110 1111 switch (mode) { 1112 case PM_POST_HIBERNATION: 1113 case PM_POST_SUSPEND: 1114 if (!acpi_battery_present(battery)) 1115 return 0; 1116 1117 if (!battery->bat.dev) { 1118 result = acpi_battery_get_info(battery); 1119 if (result) 1120 return result; 1121 1122 result = sysfs_add_battery(battery); 1123 if (result) 1124 return result; 1125 } else 1126 acpi_battery_refresh(battery); 1127 1128 acpi_battery_init_alarm(battery); 1129 acpi_battery_get_state(battery); 1130 break; 1131 } 1132 1133 return 0; 1134 } 1135 1136 static int battery_bix_broken_package_quirk(const struct dmi_system_id *d) 1137 { 1138 battery_bix_broken_package = 1; 1139 return 0; 1140 } 1141 1142 static int battery_notification_delay_quirk(const struct dmi_system_id *d) 1143 { 1144 battery_notification_delay_ms = 1000; 1145 return 0; 1146 } 1147 1148 static struct dmi_system_id bat_dmi_table[] = { 1149 { 1150 .callback = battery_bix_broken_package_quirk, 1151 .ident = "NEC LZ750/LS", 1152 .matches = { 1153 DMI_MATCH(DMI_SYS_VENDOR, "NEC"), 1154 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"), 1155 }, 1156 }, 1157 { 1158 .callback = battery_notification_delay_quirk, 1159 .ident = "Acer Aspire V5-573G", 1160 .matches = { 1161 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 1162 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"), 1163 }, 1164 }, 1165 {}, 1166 }; 1167 1168 /* 1169 * Some machines'(E,G Lenovo Z480) ECs are not stable 1170 * during boot up and this causes battery driver fails to be 1171 * probed due to failure of getting battery information 1172 * from EC sometimes. After several retries, the operation 1173 * may work. So add retry code here and 20ms sleep between 1174 * every retries. 1175 */ 1176 static int acpi_battery_update_retry(struct acpi_battery *battery) 1177 { 1178 int retry, ret; 1179 1180 for (retry = 5; retry; retry--) { 1181 ret = acpi_battery_update(battery, false); 1182 if (!ret) 1183 break; 1184 1185 msleep(20); 1186 } 1187 return ret; 1188 } 1189 1190 static int acpi_battery_add(struct acpi_device *device) 1191 { 1192 int result = 0; 1193 struct acpi_battery *battery = NULL; 1194 1195 if (!device) 1196 return -EINVAL; 1197 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL); 1198 if (!battery) 1199 return -ENOMEM; 1200 battery->device = device; 1201 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME); 1202 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS); 1203 device->driver_data = battery; 1204 mutex_init(&battery->lock); 1205 mutex_init(&battery->sysfs_lock); 1206 if (acpi_has_method(battery->device->handle, "_BIX")) 1207 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags); 1208 1209 result = acpi_battery_update_retry(battery); 1210 if (result) 1211 goto fail; 1212 1213 #ifdef CONFIG_ACPI_PROCFS_POWER 1214 result = acpi_battery_add_fs(device); 1215 #endif 1216 if (result) { 1217 #ifdef CONFIG_ACPI_PROCFS_POWER 1218 acpi_battery_remove_fs(device); 1219 #endif 1220 goto fail; 1221 } 1222 1223 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n", 1224 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device), 1225 device->status.battery_present ? "present" : "absent"); 1226 1227 battery->pm_nb.notifier_call = battery_notify; 1228 register_pm_notifier(&battery->pm_nb); 1229 1230 device_init_wakeup(&device->dev, 1); 1231 1232 return result; 1233 1234 fail: 1235 sysfs_remove_battery(battery); 1236 mutex_destroy(&battery->lock); 1237 mutex_destroy(&battery->sysfs_lock); 1238 kfree(battery); 1239 return result; 1240 } 1241 1242 static int acpi_battery_remove(struct acpi_device *device) 1243 { 1244 struct acpi_battery *battery = NULL; 1245 1246 if (!device || !acpi_driver_data(device)) 1247 return -EINVAL; 1248 device_init_wakeup(&device->dev, 0); 1249 battery = acpi_driver_data(device); 1250 unregister_pm_notifier(&battery->pm_nb); 1251 #ifdef CONFIG_ACPI_PROCFS_POWER 1252 acpi_battery_remove_fs(device); 1253 #endif 1254 sysfs_remove_battery(battery); 1255 mutex_destroy(&battery->lock); 1256 mutex_destroy(&battery->sysfs_lock); 1257 kfree(battery); 1258 return 0; 1259 } 1260 1261 #ifdef CONFIG_PM_SLEEP 1262 /* this is needed to learn about changes made in suspended state */ 1263 static int acpi_battery_resume(struct device *dev) 1264 { 1265 struct acpi_battery *battery; 1266 1267 if (!dev) 1268 return -EINVAL; 1269 1270 battery = acpi_driver_data(to_acpi_device(dev)); 1271 if (!battery) 1272 return -EINVAL; 1273 1274 battery->update_time = 0; 1275 acpi_battery_update(battery, true); 1276 return 0; 1277 } 1278 #else 1279 #define acpi_battery_resume NULL 1280 #endif 1281 1282 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume); 1283 1284 static struct acpi_driver acpi_battery_driver = { 1285 .name = "battery", 1286 .class = ACPI_BATTERY_CLASS, 1287 .ids = battery_device_ids, 1288 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 1289 .ops = { 1290 .add = acpi_battery_add, 1291 .remove = acpi_battery_remove, 1292 .notify = acpi_battery_notify, 1293 }, 1294 .drv.pm = &acpi_battery_pm, 1295 }; 1296 1297 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie) 1298 { 1299 if (acpi_disabled) 1300 return; 1301 1302 dmi_check_system(bat_dmi_table); 1303 1304 #ifdef CONFIG_ACPI_PROCFS_POWER 1305 acpi_battery_dir = acpi_lock_battery_dir(); 1306 if (!acpi_battery_dir) 1307 return; 1308 #endif 1309 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) { 1310 #ifdef CONFIG_ACPI_PROCFS_POWER 1311 acpi_unlock_battery_dir(acpi_battery_dir); 1312 #endif 1313 return; 1314 } 1315 return; 1316 } 1317 1318 static int __init acpi_battery_init(void) 1319 { 1320 async_schedule(acpi_battery_init_async, NULL); 1321 return 0; 1322 } 1323 1324 static void __exit acpi_battery_exit(void) 1325 { 1326 acpi_bus_unregister_driver(&acpi_battery_driver); 1327 #ifdef CONFIG_ACPI_PROCFS_POWER 1328 acpi_unlock_battery_dir(acpi_battery_dir); 1329 #endif 1330 } 1331 1332 module_init(acpi_battery_init); 1333 module_exit(acpi_battery_exit); 1334