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