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